home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / arith / ivec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  5.9 KB  |  259 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  ivec.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. /*              ivec.c           RD, 18.12.89 */
  17.  
  18. /*    RD, 11.9.91, vecsri hinzugefuegt    */
  19. /*    RD, 27.9.91, veceq, vecgt, vecsr1, vecsri jetzt in iplace.c */
  20.  
  21. #include <LEDA/impl/iint.h>
  22. #include <LEDA/impl/iloc.h>
  23.  
  24. #ifdef USE_DOUBLEPLACE
  25.  
  26. #ifndef ATARI
  27. #ifndef __PARC__
  28. int cvadd(sum, a, b, counta, countb)
  29.         register pPLACE sum, a, b; 
  30.         register int counta, countb;
  31.         /* sum[]=a[counta]+b[countb]; 
  32.        sum soll auch Uebertraege fassen */
  33. {       register DOUBLEPLACE accu = 0;
  34.     register int countmax;
  35.     if (counta>countb) {
  36.         countmax=counta;
  37.         counta-=countb;
  38.             for ( ; countb>0; countb--) {
  39.                     accu+=*a++;
  40.                     accu+=*b++;
  41.                     *sum++=accu;
  42.                     accu >>= LOGRADIX;
  43.             }
  44.             for ( ; counta>0; counta--) {
  45.                     accu+=*a++;
  46.                     *sum++=accu;
  47.                     accu >>= LOGRADIX;
  48.             }
  49.     } else {
  50.         countmax=countb;
  51.         countb-=counta;
  52.             for ( ; counta>0; counta--) {
  53.                     accu+=*a++;
  54.                     accu+=*b++;
  55.                     *sum++=accu;
  56.                     accu >>= LOGRADIX;
  57.             }
  58.             for ( ; countb>0; countb--) {
  59.                     accu+=*b++;
  60.                     *sum++=accu;
  61.                     accu >>= LOGRADIX;
  62.         }    }
  63.     *sum=accu;
  64.     if (accu)
  65.         return countmax+1;
  66.     else
  67.         return countmax;
  68. }    /* cvadd */
  69. #endif
  70. #endif
  71.  
  72. #ifndef ATARI
  73. #ifndef __PARC__
  74. void cvecsubto(a, b, count)
  75.         register PLACE *a, *b; 
  76.         register int count;
  77.         /* a[]-=b[count]; a muss groesser oder gleich b sein */
  78. {       register SDOUBLEPLACE accu = 0;
  79.         for ( ; count>0; count--) {
  80.                 accu+=*a;
  81.                 accu-=*b++;
  82.                 *a++=accu;
  83.                 accu >>= LOGRADIX;
  84.         }
  85.         while (accu) {
  86.                 accu+=*a;
  87.                 *a++=accu;
  88.                 accu >>= LOGRADIX;
  89.         }
  90. }        /* cvecsubto */
  91. #endif
  92. #endif
  93.  
  94. #ifndef __PARC__
  95. #ifndef ATARI
  96. int cvsub(diff, a, b, counta, countb)
  97.     register pPLACE diff, a, b;
  98.     register int counta, countb;
  99.     /* diff[]=a[counta]-b[countb]; a>=b */
  100. {       register SDOUBLEPLACE accu = 0;
  101.     register int l=counta;
  102.     counta-=countb;
  103.     for ( ; countb>0; countb--) {
  104.         accu+=*a++;
  105.         accu-=*b++;
  106.         *diff++=accu;
  107.         accu>>=LOGRADIX;
  108.     }
  109.     while (accu) {
  110.         accu+=*a++;
  111.         *diff++=accu;
  112.         accu >>= LOGRADIX;
  113.         counta--;
  114.     }
  115.     for ( ; counta>0; counta--) {
  116.         *diff++=*a++;
  117.     }
  118.     diff--;
  119.     while ((l>0)&&(! *diff)) {
  120.         diff--;
  121.         l--;
  122.     }
  123.     return l;
  124. }        /* cvsub */
  125. #endif
  126. #endif
  127.  
  128. PLACE vecaddto(a, b, count)
  129.         register PLACE *a, *b; 
  130.         register int count;
  131.         /* a[count]+=b[count]; return carry; */
  132. {       register DOUBLEPLACE accu = 0;
  133.         for ( ; count>0; count--) {
  134.                 accu+=*a;
  135.                 accu+=*b++;
  136.                 *a++=accu;
  137.                 accu >>= LOGRADIX;
  138.         }
  139.         return accu;
  140. }
  141.  
  142. PLACE vecsubto(a, b, count)
  143.         register PLACE *a, *b; 
  144.         register int count;
  145.         /* a[count]-=b[count]; return carry; 0 oder 1 */
  146. {       register SDOUBLEPLACE accu = 0;
  147.         for ( ; count>0; count--) {
  148.                 accu+=*a;
  149.                 accu-=*b++;
  150.                 *a++=accu;
  151.                 accu >>= LOGRADIX;
  152.         }
  153.         return (accu & 1);
  154. }
  155.  
  156. #ifndef __PARC__
  157. #ifndef ATARI
  158. #ifdef __GNUC__
  159. PLACE vecdiv(PLACE *q, PLACE *a, PLACE d, int count)
  160. #else
  161. PLACE vecdiv(q, a, d, count)
  162.         register PLACE *q, *a;
  163.     register PLACE d;
  164.         register int count;
  165. #endif
  166.         /* q[count]=a[count]/d; return a[count]%d; */
  167. {       register DOUBLEPLACE accu=0;
  168.         for (q+=count, a+=count; count>0; count--) {
  169.                 accu <<= LOGRADIX;
  170.                 accu+=*--a;
  171.                 *--q=accu/d;
  172.                 accu%=d;
  173.         }
  174.         return accu;
  175. }
  176. #endif
  177. #endif
  178.  
  179. #ifndef __PARC__
  180. #ifndef ATARI
  181. #ifdef __GNUC__
  182. PLACE vecmul(PLACE *product, PLACE *a, PLACE m, int count)
  183. #else
  184. PLACE vecmul(product, a, m, count)
  185.         register PLACE *product, *a, m;
  186.         register int count;
  187. #endif
  188.         /* product[count]=m*a[count]; return carry; */
  189. {       register DOUBLEPLACE accu=0;
  190.     register DOUBLEPLACE prod;
  191.         for ( ; count>0; count--) {
  192.         prod=*a++;
  193.         prod*=m;
  194.                 accu+=prod;
  195.                 *product++ = accu;
  196.                 accu >>= LOGRADIX;
  197.         }
  198.         return accu;
  199. }        /* vecmul */
  200. #endif
  201. #endif
  202.  
  203. #ifndef ATARI
  204. #ifndef __PARC__
  205. #ifdef __GNUC__
  206. PLACE vecmuladd(PLACE *paccu, PLACE *a, PLACE m, int count)
  207. #else
  208. PLACE vecmuladd(paccu, a, m, count)
  209.         register PLACE *paccu, *a, m; 
  210.         register int count;
  211. #endif
  212.         /* paccu[count] += m*a[count]; return carry; */
  213. {       register DOUBLEPLACE accu=0;
  214.     register DOUBLEPLACE prod;
  215.         for ( ; count>0; count--) {
  216.                 accu+=*paccu;
  217.         prod=*a++;
  218.         prod*=m;
  219.                 accu+=prod;
  220.                 *paccu++ = accu;
  221.                 accu >>= LOGRADIX;
  222.         }
  223.         return accu;
  224. }        /* vecmuladd */
  225. #endif
  226. #endif
  227.  
  228. #ifndef __PARC__
  229. #ifndef ATARI
  230. #ifdef __GNUC__
  231. PLACE vecmulsub(PLACE *paccu, PLACE *a, PLACE m, int count)
  232. #else
  233. PLACE vecmulsub(paccu, a, m, count)
  234.         register PLACE *paccu, *a, m;
  235.         register int count;
  236. #endif
  237.         /* paccu[count+1] -= m*a[count]; return carry; 
  238.         carry ist 0 oder 1 */
  239. {       register DOUBLEPLACE accu;
  240.         register SDOUBLEPLACE saccu=0;
  241.         for ( ; count>0; count--) {
  242.                 accu =*a++;
  243.         accu*=m;
  244.                 saccu=saccu + *paccu - (PLACE)accu;
  245.                 *paccu++ = saccu;
  246.                 saccu >>= LOGRADIX;
  247.                 accu>>=LOGRADIX;
  248.                 saccu-=accu;
  249.         }
  250.         saccu += *paccu;
  251.         *paccu = saccu;
  252.         saccu >>= LOGRADIX;
  253.         return (saccu & 1);
  254. }
  255. #endif
  256. #endif
  257.  
  258. #endif
  259.